Add benchmarks that run on the CI - #164

benchmarks/ measures what calling C++ functions through cppjit costs,
as the instructions callgrind counts for a call. Counts do not depend
on the machine's load, so one call per case is enough, and runs on
different machines with the same toolchain compare.

The C++ side (benchmarks/cpp/, built by benchmarks/Makefile into
callsDict.so) declares the benchmarked API once and includes it into
three namespaces: `hot` for successive calls, and `warmup` and `cold`
for first calls, since a function has only one first call. The API
covers single-overload functions over every primitive type (by value,
pointer, reference and const reference), strings, classes and enums; a
non-templated overload set; single and overloaded templates; and
overloaded higher order functions taking a Python callback. The bodies
only return their input, so the counts are cppjit's overhead. Markers
in the library toggle callgrind's counting and dump each count under
its test's name.

test_calls.py measures every case twice: the first call, from `cold`
after warming up on `warmup`, and a successive call, from `hot`. Only
the call is counted, with the garbage collector held off; the lookup
and the arguments are built before. Every result is checked, so a case
that resolves to the wrong overload fails instead of measuring the
wrong call. Run without callgrind, the tests only check.

callgrind.sh counts the suite. It rebuilds the library with the
valgrind headers, and runs Python with ASLR off, a fixed hash seed and
a fixed environment, since pointer-keyed hash tables and the
environment's size otherwise move the counts from run to run.

report.py collects the dumps into JSON, compares two sets of counts
into a markdown report that fails above a threshold, and exports
counts for github-action-benchmark.